MacFormat 1995 December/macformat-031.iso/mac/Shareware City/Developers/enter-act-34/EnterAct Stuff/EnterAct in brief

Text File | 1995-09-09 | 13.1 KB | 302 lines | [TEXT/KEEN]

*********EnterAct in brief (THIS IS NOT THE MANUAL) *************

EnterAct is a full C/C++ project-oriented editor, with
additional code definition display capabilities. And then some.

 Most of EnterAct's best features work with first-draft,
 uncompilabe code. As long as the delimiters balance and
 the key words are not too badly misspelled, EnterAct will
 provide instant definition and prototype display, a class
 browser, jumping to definitions, cross-referencing etc.


Necessary things
---------------

    Installation
Put EnterAct 3 and the "Drag_on Modules" folder next to the
folder that holds the mac toolbox headers you wish to use.
Symantec: next to the THINK Project Manager
metrowerks: next to the compiler you're using
MPW: next to the "Interfaces" folder.

    Making a new project
Select "New Project" (this same dialog appears when you start up
EnterAct and cancel the "Open Project"dialog).
Give your project a name, and save it.
Add files with the "Add Files..." or "Add All in Folder..." commands -
hold down the <Shift> key and the latter becomes "Add All in
Subfolders...". With the "Add All" commands, use the button at the
bottom of the dialog to add whole folders at once.
To add all toolbox headers, pick "Add Mac Headers".
Add as many or as few files as you want, regardless of whether
they make up a complete project. Neglect not non-source files
(spec, design etc) which end up in the rightmost project window
pane. Source files are in the left pane, headers in the middle. To
force files with nonstandard extensions into particular panes, use
"File Extensions....".

NOTE if a folder's name is in parentheses, the files in it will not
be added to your project. To exclude a folder such as "Old Source",
change its name to "(Old Source)".

If you add more than one file with the same name, truncated full
path names will appear to the right of the file name, to help you
tell which file is which.

The project window responds to many keys in standard ways.
Go left and right across the three panes with the left and right
arrow keys, <Command><down arrow> to go to the bottom of a
pane etc. To type your way to a particular file, you can type
the first part of the name or any distinctive part of the name
(useful if you have a lot of files whose names all begin with the
same prefix, eg to advance to "PROJECT7_Mouse.c" you could
probably type just "mou").

You can open a file from your project window by double-clicking
on it, or hitting <Return>, or use "Go to..." with the name selected.
In all cases, the project window itself will go all the way to the back.

Please add this file to your project for handy reference (use "Add
Front File"), and add the "EnterAct 3 Manual" as well - eventually,
you'll want to browse through it.

    Building a project dictionary
Select "Update Dictionary". If you run into a problem, see
«EnterAct 3 Manual» 108.
(click in the line above and select "Go to..." from the Search menu -
if you've added the manual to your project, this will open the
manual and take you to line 108.)
Note with v3.0.5 EnterAct's parser is smarter about handling
preprocessor tangles, and problems are very rare.

To exlude a file from being built into your dictionary, hold down
the <Command> key and click on its name in the project window.
A dash '-' will appear to the left of its name, meaning your
dictionary will be "minus" that file.

Now and then (typically when lookup doesn't give expected
results) issue an "Update Dictionary" to keep your
dictionary current. Once a day, once a week, whatever feels right.

    Looking up definitions
For any sort of lookup to work, you must have a project with
built dictionary open.

Select "AutoLook": when you double-click on or click after a C
name in any window, the AutoLook window will display its
definition. This includes all names for structs, unions, enums,
enum constants, functions, methods, classes, file or global scope
variables, defines, provided only that they are defined outside of
function and struct bodies (plus slightly more - see the manual).

As of version 3, the AutoLook window can also display definitions
of local variables. For this to work, the file in question must be
a source file (ie its name must end in .c or cp etc).
Double-clicking on or clicking after a local variable name will
then produce a definition in the AutoLook window.

And as of v3.3, AutoLook also produces fast accurate results for data
members when you're working in a method, provided the data member
is in the current method's inheritance chain (the class that owns
the method you're working in, plus all base classes from which
it is derived, and their bases etc). The name being looked up must
match the beginning of a data member's name exactly. In the display
box for the AutoLook window you'll see "member of" followed by
the name of the class from which the declaration was taken.

Please note that lookup for data members that aren't in the
current methods' inheritance chain is slower and less accurate.

For a more permanent separate display of the definition, press the
<Enter> key. A separate lookup window will appear. Hold down the
<Option> key and drag in the lookup window's title bar to select the
exact definition you want from a popup menu. Note that local
variables are at present excluded, you'll have to Copy and Paste
from the AutoLook window if you want a separate view of them.

To look up the struct or class containing a particular member,
again double-click on or click to the right of the name and press
<Shift><Enter>. A lookup window will appear, holding struct or
class definitions that contain the member. There will often be
several, so use the lookup window's popup menu as described just
above to pick the one you want. The AutoLook window
will often display the definition you want, though there may
be a delay of a second or so.

To use EnterAct as a lookup aid while working mainly with
some other editor: have a relevant EnterAct project open,
dictionary built, AutoLook open and frontmost; in the other
editor, Copy the term you want looked up, and switch to
EnterAct. If the definition does not immediately appear in
the AutoLook window, press <Commmand><Enter>. If it was
a member name and you want the definition of the containing
struct or class, press <Shift><Command><Enter>.

All lookup windows including AutoLook are fully editable but
cannot be saved.

    Browsing
Select "Browse" from the EnterAct menu. Browse as in THINK C.
Click and <Shift>click on and off of class names to show/hide
multiple inheritance lines. (As mentioned, class browsing works
with first-draft code.)

If a class "uses" or "has" member classes, these will be listed
below the main class name, separated from it by a white line.
You can also double-click on these names to jump to their
definitions, or click-and-hold to select one of their method
names from a popup.

The multiple inheritance lines often aren't enough, so if you
<Option> or <Command> click on a class name you'll see a popup
listing all of the classes from which it is derived. If you let
go the mouse while over one of these base class names you'll
jump to its definition.

    Finding Definitions
Single words: <Option>double-click.

Full method names (eg "TCircle::Draw") : select the full name
and use "Find Definition". Or, <Option>double-click on one word,
drag to the other, and release.

Just the method name (eg "Draw") : normally the AutoLook
window will show a full list of methods with the given
name, and you can jump to the one you want with <Option>
double-click or "Find Definition" as described just above.
If the AutoLook window doesn't show the one you want,
press <Enter>; a lookup window appears holding full
prototypes for all methods with that name; use the lookup
window's popup menu to pick the one you want; then jump
to it as described above for full method names.

More than one definition for a term:
press <Enter> to look the name up; use the popup menu in the
lookup window to pick the definition you want (<Option> click
in the window's title bar); and then use <Option>double-click on
the name, or "Find Definition" without changing the default
selection. The popup menu includes truncated full path names
for the defining files, so you can tell which definition is which.

Static functions and variables: if you're in the file where it is
defined, just <Option>double-click on the name. If you have
several definitions of such a name and you aren't in the file where
it is defined, use the approach for more than one definition described
just above.

    Multi-file search
The Find dialog contains buttons to select all files of a particular
type in the project window. Files selected for multi-file
operations (including searching) have bullets (•) to their left in
the project window. To "fine tune" your multi-file selection, hold
down the <Option> key and click or drag right in the project
window.

The "Batch" check box generates a list of all lines where the search
string can be found in your multi-file selection. To jump to the
file and line indicated for one of the finds, click on the line and
use "Go to...".

Multi-file selections have other uses, such as "Remove •'d files",
input for several "Index" commands, and input for hAWK programs
(see the «hAWK User’s Manual» for the last).

In the Find dialog, the "Skip '-'" checkbox allows you to exclude
files marked with a dash '-' in the project window when doing
a multi-file operation such as searching.

    Accessing THINK Reference
Beside EnterAct at the same level, have a folder entitled "Tools"
or "(Tools)"; drop an alias of THINK Reference in this folder.

To look up THINK Ref's thoughts on a term, select it or click
to the right of it and issue "Find in THINK Reference".

    Accessing Toolbox Assistant
As for THINK Ref, but drop an alias of "QuickView" in your
Tools folder. The "Find in Toolbox Assistant" command is
at the bottom of the Search menu.

    Editing and Undo
All basic editing commands are undoable, with a single level
of undo.

As you work, EnterAct logs all of your activities (including
contents of edits) to the "EnterAct Recent Activities" file. In a
pinch, you can recover the contents of a delete or remind yourself
of what you just did by selecting "Show Activities..." from
the Edit menu.

Well, not all of your activities, only the last ten thousand.

See «EnterAct 3 Manual» 4479 for a new and nicer way to cut
and paste blocks of code.

    Working with Code Warrior
By default, when you open a document and Code Warrior also
has the document open, EnterAct will force Code Warrior to
close and save the file before opening it, asking you first of
course before doing so. To turn this off,
deselect the "Safe switching under MultiFinder" option
in the Options... dialog (under the Edit menu). Having this
option on also means that EnterAct will save all your
documents when you switch out, and refresh them from
disk when you switch back if they have been changed by
some other application.

Other useful things
-----------------
You can Balance a delimiter by double-clicking on it.

EnterAct comes equipped with hAWK, a version of AWK. It really
is "three clicks and Run", with many supplied programs. See the
«hAWK User’s Manual» for details.

EnterAct's <Enter>-driven lookup tolerates many kinds of spelling
and (more importantly) memory errors. When in doubt, give it your
best guess and press <Enter>. For extreme cases, use the "Options"
dialog to increase the "Number of entries per lookup window" to 20.
For emergency use only, use <Option><Enter> instead of plain <Enter>
to fire up EnterAct's most error tolerant definition retriever - be
prepared for some wild guesses mixed in there with the good ones!

To look up the last word on the clipboard, typically copied while in
another application, press <Command><Enter>. Note if you have
the AutoLook window open it will automatically show a definition
for a word on the clipboard as you switch back to EnterAct.

"Go to..." is very nearly as general as it can be. It accepts line
numbers, file names, marker names, and combinations such as
file name/marker name, file name/line number. Handy for placing
references in code files to supporting documentation. Moderately
error tolerant, full correct spelling not required. To see it work,
add the "EnterAct 3 Manual" to your project if you haven't done so,
then click anywhere on the following line and "Go to":
«EnterAct 3 Man» «17   “Go” cmds»

The European-style quotes «» are helpful in most "Go to" link names;
to generate these painlessly, see
«EnterAct 3 Man»  5890 (any individual mark)
and
«EnterAct 3 Man» 7392(marks in documentation files especially)

EnterAct projects accept PICT files.

Printing doesn't clip off long lines, it wraps them around.

EnterAct can be used as the THINK Project Managers's editor,
as explained in either the THINK or EnterAct manuals.

When EnterAct can't locate a project file, and you have enabled
the "Relocate files automatically" option,  it starts searching
at the top of the disk where the file was last seen and
searches down until it finds it (or not). Renaming or moving
a folder does not affect EnterAct's memory of where a file is.

That's more than enough to get going. If you become inordinately
fond of EnterAct's definition lookup capabilities, be sure to read
through the full manual for details on the above features and a
host of others.